function foo() {
    // Promise.resolve静态方法
    // 1.是一个普通值
    // 2.返回一个promise,状态有返回值决定
    // 3. 一个实现了then方法的对象,那么本状态移交给then方法决定
    // return Promise.resolve('1111')

    // Promise.reject静态方法
    // 不管传入的是什么都是err和resolve一样
    return Promise.reject(222)
    // return Promise.reject(Promise.resolve(333))
}
foo().then(res => {
    console.log('foo  res  ', res);
}).catch(err => {
    console.log('foo  err  ' + err);
})

const p1 = new Promise((res, rej) => {
    rej(1)
})
const p2 = new Promise((res, rej) => {
    rej(2)
})
const p3 = new Promise((res, rej) => {
    rej(3)
})

// Promise.all() 方法接收一个 promise 的 iterable 类型（注：Array，Map，Set 都属于 ES6 的 iterable 类型）的输入，
// 并且只返回一个Promise实例，那个输入的所有 promise 的 resolve 回调的结果是一个数组。
// 这个Promise的 resolve 回调执行是在所有输入的 promise 的 resolve 回调都结束，
// 或者输入的 iterable 里没有 promise 了的时候。
// 它的 reject 回调执行是，只要任何一个输入的 promise 的 reject 回调执行或者输入不合法的 promise 就会立即抛出错误，
// 并且 reject 的是第一个抛出的错误信息
Promise.all([p1, p2, p3]).then(res => {
    console.log('Promise.all res ' + res);
}).catch(err => {
    console.log('Promise.all err ' + err);
})

// 当输入的所有 promise 都已敲定时（包括传递空的可迭代类型），返回的 promise 将兑现，并带有描述每个 promsie 结果的对象数组。
Promise.allSettled([p1, p2, p3]).then(res => {
    console.log('Promise.allSettled res ' + res);
    res.map(console.log)
}).catch(err => {
    console.log('Promise.allSettled err ' + err);
})

// Promise.race(iterable) 方法返回一个 promise，一旦迭代器中的某个 promise 解决或拒绝，返回的 promise 就会解决或拒绝。
Promise.race([p1, p2, p3]).then(res => {
    console.log('Promise.race res ' + res);
}).catch(err => {
    console.log('Promise.race err ' + err);
})


// Promise.any() 接收一个由 Promise 所组成的可迭代对象，该方法会返回一个新的 promise，
// 一旦可迭代对象内的任意一个 promise 变成了兑现状态，那么由该方法所返回的 promise 就会变成兑现状态，
// 并且它的兑现值就是可迭代对象内的首先兑现的 promise 的兑现值。
// 如果可迭代对象内的 promise 最终都没有兑现（即所有 promise 都被拒绝了），
// 那么该方法所返回的 promise 就会变成拒绝状态，
// 并且它的拒因会是一个 AggregateError 实例，这是 Error 的子类，用于把单一的错误集合在一起。
Promise.any([p1, p2, p3]).then(res => {
    console.log('Promise.any res ' + res);
}).catch(err => {
    console.log('Promise.any err ' + err.errors);
})
